#include "thread_test_v1.h"

thread_test_V1::thread_test_V1(size_t numThreads) {
    for (size_t i = 0; i < numThreads; ++i) {
        workers.emplace_back([this]() {
            while (true) {
                Task task;
                {
                    // 获取任务
                    std::unique_lock<std::mutex> lock(queueMutex);
                    condition.wait(lock, [this]() { return stop || !taskQueue.empty(); });
                    if (stop && taskQueue.empty())
                        return;
                    task = taskQueue.top();
                    taskQueue.pop();
                }
                // 执行任务
                task.func();
            }
        });
    }
}


thread_test_V1::~thread_test_V1() {
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        stop = true;
    }
    condition.notify_all();
    for (std::thread& worker : workers)
        worker.join();
}


std::shared_ptr<std::atomic<bool>> thread_test_V1::enqueue_task(
    std::function<void(std::shared_ptr<std::atomic<bool>>)> cancelableTaskFunc,
    std::function<void()> normalTaskFunc,
    bool supportCancel,
    int priority,
    std::chrono::milliseconds timeout
    ) {
    if (supportCancel && !cancelableTaskFunc) {
        throw std::invalid_argument("Error Task");
    }
    if (!supportCancel && !normalTaskFunc) {
        throw std::invalid_argument("Error Task");
    }

    std::shared_ptr<std::atomic<bool>> cancelFlag = nullptr;

    if (supportCancel) {
        // 创建取消标志，并返回给调用者
        cancelFlag = std::make_shared<std::atomic<bool>>(false);
    }

    // 创建一个任务包装器
    auto taskWrapper = [cancelableTaskFunc, normalTaskFunc, supportCancel, timeout, cancelFlag]() {
        if (supportCancel) {
            //如果设置了超时时间，启动定时器线程
            if (timeout != std::chrono::milliseconds::max()) {
                std::thread([cancelFlag, timeout]() {
                    std::this_thread::sleep_for(timeout);
                    cancelFlag->store(true);
                }).detach();
            }

            // 执行可取消任务函数
            cancelableTaskFunc(cancelFlag);

        } else {
            // 执行普通任务函数
            normalTaskFunc();
        }
    };

    // 将任务加入任务队列
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        taskQueue.emplace(Task{priority, taskWrapper, ++taskCounter});
    }
    condition.notify_one(); // 通知工作线程

    // 返回取消标志
    return cancelFlag;
}
